# import time
# from multiprocessing import Process
#
#
# # 吃饭 任务
def eat(name):
    for i in range(6):
        print(f'正在吃饭 ...{name}')
        time.sleep(0.3)


# 做作业任务
def work():
    for i in range(6):
        print('正在执行任务')
        time.sleep(0.5)


#
# if __name__ == '__main__':
#     # 创建一个子进程，每个任务由一个独立的子进程来完成
#     p1 = Process(target=eat, name='进程1')
#     p2 = Process(target=work, name='进程2')
#
#     # 启动
#     p1.start()
#     p2.start()
#
#     # 主进程自动等待，所有的子进程去执行各自的任务，一直到所有的子进程都结束，主进程才结束


# 通过面向对象的形式去创建进程
import time
from multiprocessing import Process, Pool

# from multiprocessing.pool import Pool

#
# class EatProcess(Process):
#     """写一个自定义的类，继承Process"""
#
#     def __init__(self, name):
#         super().__init__()  # 这行代码必须要有，因为真正负责创建进程的准备工作，全部是由父类完成的
#         self.name = name  # 自己只是额外增加了一个属性
#
#     def run(self) -> None:
#         for i in range(6):
#             print(f'进程{self.name}:正在吃饭....')
#             time.sleep(0.5)
#
#
# class WOrkProcess(Process):
#     def __init__(self, name):
#         super().__init__()
#         self.name = name
#
#     def run(self) -> None:
#         for i in range(6):
#             print(f'进程{self.name}:正在工作....')
#             time.sleep(0.5)


if __name__ == '__main__':
    # p1 = EatProcess('process-1')
    # p2 = WOrkProcess('process-2')
    #
    # p1.start()
    # p1.join() # join()函数会使主进程阻塞，一直到当前子进程结束
    # p2.start()

    # 创建进程池
    process_pool = Pool(2)
    # apply 函数是一个阻塞函数（主进程） 一般不这样写
    # process_pool.apply(eat,args=('张三'))  # 从进程池中请求一个新的进程去执行eat
    # process_pool.apply(work,)

    # 一般这样写异步的进程池
    process_pool.apply_async(eat, args='张三')
    process_pool.apply_async(work)

    # 表示进程池关闭，进程池不在接受新的请求
    process_pool.close()
    # 采用进程池的异步调用，一定要手动的调用join函数
    process_pool.join()
